package pokerSaloon;
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */


import java.rmi.*;
import java.rmi.server.*;

import pokerSaloon.model.Carte;
import pokerSaloon.model.CartePrivee;
import pokerSaloon.model.Main;
import pokerSaloon.model.TableauImpl;
import pokerSaloon.vue.OutilsInterface;
import pokerSaloon.vue.fenAccueil;
import pokerSaloon.vue.fenAttenteJoueur;
import pokerSaloon.vue.fenJeu;
import pokerSaloon.vue.fenListePartie;

/**
 *
 * @author Gombert Foucras Valery
 */
public class Joueur extends UnicastRemoteObject implements InterJoueur {

    /**
	 * 
	 */
	private static final long serialVersionUID = -7752839456890623742L;


    /** Constante définissant le port du serveur PokerSaloon */
    private static final int PORT = 1099;
    /** Serveur distant Poker Saloon */
    private static InterPokerSaloon serveur;
    /** Le joueur */
    private static Joueur user;
    /** Adresse IP du serveur */
    private static String ip;
    /** Pseudonyme du joueur. */
    private static String pseudo;
    /** Cave du joueur. */
    private static int cave;
    /** Mise du joueur. */
    private static int mise;
    /** Determine si le joueur et couché ou non. */
    private static boolean couche;
    /** Instances des fenêtres de l'interface graphique du joueur. */
    private static fenListePartie fenPartie;
    private static fenJeu jeu;
    private static fenAttenteJoueur fenAttente;
    private static InterPartie partieChoisie;
    /**
	 * Cartes privees du joueur.
	 * @uml.property  name="cartesJoueur"
	 * @uml.associationEnd  
	 */
    private CartePrivee cartesJoueur;

    
    /**
     * Constructeur par défaut de la classe.
     * @throws RemoteException En cas d'erreur de communication réseau.
     */
    public Joueur(String pseudo) throws RemoteException {
    }

    /**
     * ordre venant du serveur permettant de demarrer la partie chez les joueurs de la partie
     * @throws RemoteException
     */
    public void lancerJeu() throws RemoteException {
        jeu = new fenJeu();
        cave = partieChoisie.getCAVE_INITIAL();
        fenAttente.dispose();
        jeu.setVisible(true);
    }

    /**
     * le joueur est le maitre de la partie il decide de commencer la partie
     */
    public static void lancerPartie() {
        try {
            if (partieChoisie.lancerJeu()) {
                serveur.supprimePartie(partieChoisie.getNom());

                jeu = new fenJeu();
                cave = partieChoisie.getCAVE_INITIAL();
                fenAttente.dispose();
                jeu.setVisible(true);

                partieChoisie.nouveauCoup();
                partieChoisie.getInfoJoueur();
            } else {
                OutilsInterface.manqueJoueur(jeu);
            }
        } catch (Exception ex) {
            System.out.println("erreur lancer partie : " + ex);
        }
    }


//    /**
//     * Connecter le joueur au serveur spécifié.
//     * @param c La fenetre d'accueil parente.
//     * @param ip L'adresse IP du serveur saisie par l'utilisateur.
//     * @param pseudo Le pseudonyme choisi par l'utilisateur.
//     */
//    public static void connexion(javax.swing.JFrame c, String adresseIP, String lePseudo) {
//
//        if (lePseudo.length() < 3) {
//            // Si le pseudo choisi est trop court.
//            OutilsInterface.pseudoTropCourt(c, lePseudo);
//        } else {
//
//            ip = adresseIP;
//            pseudo = lePseudo;
//
//            try {
//                // Connexion à la machine serveur.                
//                ServeurPoker.setIp(adresseIP);
//                serveur = ServeurPoker.getInstance();
//
//                user = new Joueur(pseudo);
//                // Les informations saisies sont correctes
//                fenPartie = new fenListePartie();
//
//                // Connexion du joueur au Poker Saloon.
//                if (serveur.connecter(user, pseudo)) {
//
//                    fenPartie.setVisible(true);
//                    c.dispose();
//
//                } else {
//                    // Si pseudo déjà utilisé, on affiche un message à l'utilisateur.
//                    OutilsInterface.pseudoInvalide(c, pseudo);
//                    fenPartie.dispose();
//                }
//            } catch (Exception e) {
//                System.out.println("exception : " + e);
//                // Si la connexion est impossible, on affche un message à l'utilisateur.
//                OutilsInterface.ipInvalide(c, ip);
//                fenPartie.dispose();
//            }
//        }
//    }





    /**
     * rajoute à la liste des joueurs d'une partie le joueur passé en paramètre
     * @param pseudo, du joueur a rajouter
     * @throws RemoteException
     */
    public void displayJoueur(String pseudo) throws RemoteException {
        fenAttente.actualiserJoueur(pseudo);
    }

    /**
     * rajoute a la liste des joueurs d'une partie le joueur passÃƒÂ© en paramÃƒÂ¨tre
     * @param pseudo, du joueur a rajouter
     * @throws RemoteException
     */
    public void displayInfoJoueur(String[] joueur, String[] cave1, String[] mise, String joueurCourant, int pot) throws RemoteException {
        jeu.setInfoJoueur(joueur, cave1, mise, pseudo, joueurCourant, pot);
    }


    /**
     * Parler (check)
     * @return true si l'utilisateur a pu parler,
     *         false sinon.
     */
    public static void parler() {
        try {
            if (partieChoisie.isCheckPossible()) {
                partieChoisie.toCheck(pseudo);
                partieChoisie.getInfoJoueur();
                jeu.setLogAction("Vous avez parlé (check).", false);
            } else {
                jeu.setLogAction("Vous ne pouvez pas parler (check) maintenant.", true);
            }
        } catch (RemoteException ex) {
            System.out.println("Exception : " + ex);
        }
    }

    /**
     * Suivre la mise du joueur pr�c�cent.
     * @return true si l'utilisateur a pu parler,
     *         false sinon.
     */
    public static void suivre() {
        try {
            relancer(partieChoisie.getMisePrec() - mise);
        } catch (RemoteException ex) {
            System.out.println("Exception : " + ex);
        }
    }

    /**
     * Relancer d'un certain montant.
     * @param montant de la relance.
     */
    public static void relancer(int montant) {
        try {
            int smallBlind = partieChoisie.getVAL_BIG_BLIND() / 2;
            if (montant > cave) {
                jeu.setLogAction("Vous ne pouvez pas miser " + montant + " alors que vous n'avez que " + cave + " !", true);
            } else if (montant == cave) {
                tapis();
            } else if (montant < smallBlind) {
                jeu.setLogAction("La somme de " + montant + " est insuffisante, mise minimum de " + smallBlind + ".", true);
            } else if (montant + mise < partieChoisie.getMisePrec()) {
                jeu.setLogAction("La somme de " + montant + " est insuffisante pour rester en jeu.", true);
            } else {
                cave -= montant;
                mise += montant;
                partieChoisie.toRaise(pseudo, montant);
                jeu.setLogAction("Vous avez ajouté la somme de " + montant + " au pot.", false);
                partieChoisie.getInfoJoueur();
            }
        } catch (Exception ex) {
            System.out.println("Exception : " + ex);
        }
    }

    /**
     * Miser son tapis.
     */
    public static void tapis() {
        try {
            mise = cave;
            cave=0;
            partieChoisie.allin(pseudo, mise);           
            jeu.setLogAction("Vous êtes à tapis !", false);
            partieChoisie.getInfoJoueur();
        } catch (Exception ex) {
            System.out.println("Exception : " + ex);
        }
    }

    /**
     * Se coucher. L'utilisateur abandonne le coup.
     */
    public static void seCoucher() {
        try {
            couche = true;
            partieChoisie.toFold(pseudo);
            partieChoisie.getInfoJoueur();
            jeu.setLogAction("Vous avez choisi de vous coucher. Coup terminé.", false);
        } catch (Exception ex) {
            System.out.println("Exception : " + ex);
        }
    }

    /**
     * Initialise l'attribut couche a false.
     * @throws RemoteException
     */
    public void initCouche() throws RemoteException {
        couche = false;
    }

    /**
     * Accesseur a l'attribut couche.
     * @return true ou false.
     * @throws RemoteException
     */
    public boolean getCouche() throws RemoteException {
        return couche;
    }

    /**
     * Afficher un message au joueur.
     * @param msg le message a afficher.
     */
    public void afficherMsg(String msg) throws RemoteException {
        jeu.setLogAction(msg, false);
    }

    /**
     * accesseur au pseudo pour le serveur
     * @return
     * @throws RemoteException
     */
    public String getPseudo() throws RemoteException {
        return pseudo;
    }

    /**
     * accesseur au pseudo pour l'interface
     * @return
     */
    public static String getPseudoInter() {
        return pseudo;
    }

    /**
     * Accesseur à la cave du joueur.
     * @return cave du joueur.
     */
    public int getCave() throws RemoteException {
        return cave;
    }

    /**
     * Accesseur à la mise du joueur.
     * @return mise du joueur.
     */
    public int getMise() throws RemoteException {
        return mise;
    }

    /**
     * Modifier la mise du joueur.
     * @param valeur La nouvelle valeur de la mise.
     */
    public void setMise(int valeur) throws RemoteException {
        mise = valeur;
    }

    /**
     * Modifier la cave du joueur.
     * @param valeur valeur a ajouter.
     * @throws RemoteException
     */
    public void setCave(int valeur) throws RemoteException {
        cave += valeur;
    }

    /**
     * Attribuer ses cartes privÃ©es au joueur.
     * @param carte1 - premiere carte du joueur
     * @param carte2 - seconde carte du joueur
     * @throws RemoteException
     */
    public void recevoirCarte(CartePrivee cartesJoueur) throws RemoteException {
        this.cartesJoueur = cartesJoueur;
        Carte[] temp1 = cartesJoueur.getCartesJoueur();
        jeu.setCarteJoueur(Integer.toString(temp1[0].getNumero()), Integer.toString(temp1[1].getNumero()));
    }

    /**
     * affiche les cartes du tableau sur l'interface
     * @param numCarte
     * @param i
     */
    public void displayBoard(String[] numCarte, int i) {
        jeu.setBoard(numCarte, i);
    }

    /**
     * détermine la meilleure main du joueur
     * @param board - tableau de la partie
     * @return temp - la main du joueur
     * @throws RemoteException
     */
    public Main calculMain(TableauImpl board) throws RemoteException {
        Main temp = new Main(board, cartesJoueur);
        return temp;
    }

    /**
     * nettoie le tableau du joueur courant
     * @throws RemoteException
     */
    public void clearBoard() throws RemoteException {
        jeu.clearBoard();
    }

    /**
     * quitte une partie en cours appelé par le SERVEUR
     */
    public void finPartie() throws RemoteException {
        try {
            finPartieInter();
        } catch (Exception ex) {
            System.out.println("erreur de dÃƒÆ’Ã‚Â©connexion");
        }
    }

    /**
     * quitte une partie en cours appelé par l'interface
     */
    public static void finPartieInter() {
        try {
            System.out.println("fin partie 1");
            partieChoisie.deconnecter(pseudo);
            System.out.println("fin partie 2");
            fenPartie = new fenListePartie();
            System.out.println("fin partie 3");
            serveur.getPartie();
            System.out.println("fin partie 4");
            jeu.setVisible(false);
            System.out.println("fin partie 5");
            fenPartie.setVisible(true);
            System.out.println("fin partie 6");
        } catch (RemoteException ex) {
            System.out.println("erreur de dÃƒÆ’Ã‚Â©connexion");
        }
    }

    /**
     *  le joueur courant est le gagnant d'une partie
     * @throws RemoteException
     */
    public void gagnant() throws RemoteException {
        javax.swing.JOptionPane.showMessageDialog(jeu,
                "Vous avez gagné la partie !",
                "Victoire", javax.swing.JOptionPane.INFORMATION_MESSAGE);
        finPartieInter();
    }
}
